home *** CD-ROM | disk | FTP | other *** search
/ Technotools / Technotools (Chestnut CD-ROM)(1993).ISO / os2tools / lj2os2 / lj2.c next >
Text File  |  1992-07-31  |  15KB  |  541 lines
  1.  /******************************************************************************
  2.  **
  3.  **   LJ -- A printing utility for the HP LaserJet
  4.  **
  5.  **
  6.  **   This program prints a series of files on the LaserJet printer.  The
  7.  **   files are printed in a "landscape" font at 17 characters to the inch.
  8.  **   To take advantage of this density, two "pages" of information from
  9.  **   the file are printed on each piece of paper (left and right halves).
  10.  **
  11.  **   Usage is:       LJ  file1 file2 file3 ...
  12.  **
  13.  **   Where file# is a valid MS-DOS filename, included on the command line.
  14.  **
  15.  **   Originally written by Joe Barnhart and subsequently modifed by:
  16.  **     Ray Duncan and Chip Rabinowitz.  This program has been placed in
  17.  **     the public domain for use without profit.
  18.  **
  19.  **   Revised 9/86 for the Mark Williams C Programming System,
  20.  **     Steven Stern, JMB Realty Corp.
  21.  **
  22.  **   Revised 11/86 for DOS wild card characters in the file name.
  23.  ****************************************************************************
  24.  **
  25.  **   Revised 4/88 for the DATALIGHT C Compiler by Serge Stepanoff,
  26.  **   STS Enterprises, 5469 Arlene Way, Livermore, CA.
  27.  **
  28.  **    The revised code uses the built in file wildcard expansion feature
  29.  **    of DATALIGHT C, and makes use of some additional flags to
  30.  **    turn off the Header line, optionally use the 7 point
  31.  **    Prestige Elite font, and ssome oher features.  Typing "lj2" with
  32.  **    no parameters will produce a short users' explanaion.
  33.  **
  34.  **    Program has been checked out on an OKIDATA
  35.  **    LASERLINE printer (HP Laserjet compatible).
  36.  *****************************************************************************
  37.  ** Revised 10/16/89 by Jim Derr for the Turbo C 2.0 Compiler.
  38.  ** Uses the wildargs obj module for file wild card expansion.
  39.  ** Corrected some anomalies in the code that was causing invalid pages breaks.
  40.  ** Added the -s command line option that will shade every other line on the
  41.  ** printout for readability.
  42.  *****************************************************************************
  43.  ** Revised 1/11/91 by Jim Derr.
  44.  ** added -l option to specify number of lines per page to print.
  45.  ** added -i options to ignore formfeed characters.
  46.  ** added -d option to allow for duplex printing.
  47.  **          (Note: when printing duplex only one file at a time may be
  48.  **           specified on the command line)
  49.  *****************************************************************************
  50.  ** Revised 7/31/92 by Mark Polly
  51.  ** compiled under OS/2 2.0 using C set/2.
  52.  ** removed the message "printing page nn, line nn to make it look good under
  53.  ** IBM's Workframe
  54.  **/
  55.  
  56. #include <stdio.h>
  57. #include <time.h>
  58. #include <ctype.h>
  59. #include <fcntl.h>
  60.  
  61. int     MAXLINE=66;        /* maximum lines per page on LaserJet */
  62. int     MAXLINE_RESET=66;  /* maximum lines per page on LaserJet */
  63. #define MAXVERT 69         /* maximum lines per page on LaserJet */
  64.  
  65.  
  66.  FILE *lp; 
  67.  
  68. int line_no = 1;
  69. int pagenum;
  70.  
  71. FILE *fp;               /* FILE pointer for the file to be printed */
  72.  
  73. int  hdrflag;        /* Header print suppress flag */
  74. int  pgflag;        /* Page separator flag */
  75. int  tab = 4;        /* default value of one tab stop */
  76. int  pgside;        /* left/right half of page indicator  */
  77. int  psprint = 0;   /* proportional using Helv 6 pt. */
  78. int  shade_it = 0;  /* shade every other line */
  79. int  book = 0;      /* indent left 6 additional spaces for punching*/
  80. int  maxcol=85;
  81. int  numbers = 0;
  82. int  duplex=0;
  83. int  formfeed=0;
  84.  
  85. int do_print=1;     /*flags for doing duplex printing*/
  86.  
  87. /*************************************************************************
  88.  
  89. main
  90.  
  91. *************************************************************************/
  92.  
  93. main(argc, argv)
  94. int argc;
  95. char *argv[];
  96. {
  97. int filenum;
  98. char fname[70];
  99. int first;
  100. int jim;
  101.  
  102.    if (argc <= 1)
  103.       {
  104.       usage();
  105.       exit(1);
  106.       }
  107.  
  108.  
  109.   lp = fopen("PRN","w+");
  110.  
  111. /* initialize the LaserJet for landscape printing */
  112.  
  113.    fprintf( lp,"\033E\033&l1O\033(s17H\033&l5.14C\033&l70F\033&l5E" );
  114.  
  115.    for (first = 1; first < argc; first++)  {
  116.       if (*argv[first] != '/' && *argv[first] != '-') /* check for flags */
  117.          break;                    /* and exit if none */
  118.       argv[first]++;
  119.       switch (tolower(*argv[first]))  {
  120.          case 'e':        /* Prestige Elite 7 point font */
  121.             psprint = 1;
  122.             maxcol=104;
  123.             fprintf(lp,"\033&l1O\033(0U\033(s1p6vsb4T");
  124.             break;
  125.          case 'h':        /* suppress headers flag */
  126.             hdrflag++;
  127.             MAXLINE=69;
  128.             MAXLINE_RESET=69;
  129.             break;
  130.          case 't':        /* Horizontal tab value */
  131.             tab = atoi(++argv[first]);
  132.             if (tab < 1 || tab > 8)  {
  133.                 printf("Invalid tab value specified -- defaulting to 8\n");
  134.                 tab = 8;
  135.                 }
  136.             break;
  137.          case 'l':
  138.             MAXLINE = atoi(++argv[first]);
  139.             if (MAXLINE < 1 || MAXLINE > MAXLINE_RESET)  {
  140.                 printf("Invalid lines/page value specified -- defaulting to MAX\n");
  141.                 MAXLINE = MAXLINE_RESET;
  142.                 }
  143.             break;
  144.          case 'p':      /* suppress page eject between files */
  145.             pgflag++;
  146.             break;
  147.          case 's':
  148.             shade_it++;
  149.             break;
  150.          case 'n':
  151.             numbers++;
  152.             break;
  153.          case 'b':
  154.             book++;
  155.             maxcol=79;
  156.             break;
  157.          case 'd':
  158.             duplex=1;
  159.             break;
  160.          case 'i':
  161.             formfeed++;
  162.             break;
  163.          default:
  164.             printf("Invalid Flag Specified ('%s') -- ignored.....\n",
  165.                     --argv[first]);
  166.             break;
  167.          }
  168.       }
  169.  
  170.    printf("Lines per page set to %d\n",MAXLINE);
  171.  
  172.    if(duplex) {
  173.      if((argc - 1) > first) {
  174.         printf("Only one file at a time may be printed when using DUPLEX mode.\n");
  175.         exit(1);
  176.      }
  177.    }
  178.  
  179.    for(filenum = first; filenum < argc; filenum++ )
  180.       {
  181.          copyname(fname, argv[filenum]);
  182.          fp = fopen(fname ,"r");
  183.          if( fp == NULL )
  184.             {
  185.             printf( "File %s doesn't exist.\n", fname );
  186.             }
  187.          else
  188.             {
  189.             printf( "Now printing %s\n", fname );
  190.             printfile( fname );
  191.             fclose( fp );
  192.             }
  193.       }    /* of loop through run-time args */
  194.  
  195. /*
  196.    if (pgflag & pgside)
  197.     fputc('\f', lp);
  198. */
  199.    fprintf( lp, "\r\033E" );      /* clear LaserJet */
  200.    fclose(lp);
  201.  
  202.  
  203. }
  204.  
  205. /*************************************************************************
  206.  
  207. printfile (filename)
  208.  
  209. *************************************************************************/
  210.  
  211. printfile(filename)
  212. char *filename;
  213. {
  214.    int retval = 0;
  215.    int printed = 0;
  216.    int pass=0;
  217.    char c2;
  218.    int f_feed=0;
  219.    int phys_pages=0;
  220.    int plus=1;
  221.    int z;
  222.  
  223.    pagenum=1;
  224.  
  225. do_it_again:
  226.    while( (feof(fp)==0) && (retval==0) )
  227.       {
  228.       f_feed=0;
  229.       if (pgside == 0)  {
  230.          printed = 0;
  231.          c2 = fgetc(fp);
  232.          if(feof(fp)) break;
  233.          switch (c2) {
  234.             case EOF:
  235.             case '\377':
  236.             case '\032':
  237.                 retval = -1;
  238.                 break;
  239.             default:
  240.                 printed=1;
  241.                 if(do_print) dovert();
  242.                 if(psprint && do_print)
  243.                    fprintf(lp,"\033&a0r0c120m0L\r");
  244.                 else if(book && do_print)
  245.                    fprintf(lp, "\033&a0r0c85m7L\r"); /* set LaserJet to left half */
  246.                 else if(do_print)
  247.                    fprintf(lp, "\033&a0r0c85m0L\r"); /* set LaserJet to left half */
  248.                 if(shade_it && do_print) shade();
  249.                 ungetc(c2,fp);
  250.                 header(filename, pagenum++);       /* title top of page */
  251.                 retval = printpage();                 /* print one page */
  252.                 pgside ^= 1;
  253.          }
  254.       }
  255.       if(feof(fp)==0 && retval==0)
  256.          {                                  /* if more to print... */
  257.          if(psprint && do_print)
  258.             fprintf(lp,"\033&a0r0c243m123L\r");
  259.          else if(book && do_print)
  260.             fprintf(lp, "\033&a0r0c175m97L\r");    /* LaserJet to right half */
  261.          else if(do_print)
  262.             fprintf(lp, "\033&a0r0c175m90L\r");    /* LaserJet to right half */
  263.          c2 = fgetc(fp);
  264.          if(feof(fp)) break;
  265.          switch (c2) {
  266.             case EOF:
  267.             case '\377':
  268.             case '\032':
  269.                 retval = -1;
  270.                 break;
  271.             default:
  272.                 ungetc(c2,fp);
  273.                 header(filename, pagenum++);          /* title top of page */
  274.                 retval = printpage();                 /* print one page */
  275.                 pgside ^= 1;
  276.          }
  277.       }
  278.       if (pgside == 0 && printed && do_print) {
  279.          fputc('\f', lp);
  280.          f_feed=1;
  281.       }
  282.       else if (pgflag == 0 && printed && do_print)  {
  283.          fputc('\f', lp);
  284.          pgside = 0;
  285.          f_feed=1;
  286.          }
  287.       if(f_feed) {
  288.         if(plus)
  289.             ++phys_pages;
  290.         else
  291.             --phys_pages;
  292.       }
  293.       if(duplex) do_print ^= 1;
  294.       }
  295.  
  296.  
  297.       if(duplex) {
  298.         if(pass) {
  299.             while(phys_pages) {
  300.                 fputc('\f',lp);
  301.                 --phys_pages;
  302.             }
  303.             return(0);
  304.         }
  305.         plus=0;
  306.         if(!f_feed && retval == 0) fputc('\f',lp);
  307.         fflush(lp);
  308.         ++pass;
  309.         rewind(fp);
  310.         retval=0;
  311.         pagenum=1;
  312.         do_print = 0;
  313.         printf("\nFlip the paper and press any key when ready\n");
  314.         z = getchar();
  315.         goto do_it_again;
  316.       }
  317.    return(0);
  318. }
  319.  
  320. /*******************************************************************************
  321.  
  322. printpage
  323.    print a logical page
  324.  
  325. *************************************************************************/
  326.  
  327. printpage()
  328. {
  329.    char c;
  330.    int line,col;
  331.    static int cont = 0;
  332.    static char *cont1 = "---->";
  333.  
  334.    line = col = 0;
  335.    if(cont)
  336.       {
  337.       if(do_print) fprintf(lp,cont1);
  338.       col = strlen(cont1);
  339.       cont = 0;
  340.       }
  341.  
  342.    while( line < MAXLINE )
  343.       {
  344.       c = fgetc(fp);
  345.       if(feof(fp)) return(-1);
  346.  
  347.       if(col>maxcol)
  348.          {
  349.          line++;
  350.          switch(c)
  351.             {
  352.             case '\n':
  353.             case '\r':
  354.             case '\f':
  355.             case EOF:
  356.             case '\377':
  357.             case '\032':
  358.                break;
  359.             default:
  360.                if(line >= MAXLINE)
  361.                   {
  362.                   cont = 1;
  363.                   ungetc(c,fp);
  364.                   return(0);
  365.                   }
  366.                if(do_print) fprintf(lp,"\n%s",cont1);
  367.                col = strlen(cont1);
  368.                break;
  369.             }
  370.          }
  371.  
  372.       if(col == 0) {
  373.  /*********************************************/
  374.  /* removed the following lines to make it work good under IBM's Workframe  *
  375.  *         if(do_print) {
  376.  *             printf("Printing page %4.4d line %4.4d\r",pagenum-1,line);
  377.  *         }
  378.  *         else {
  379.  *             printf("Skipping page %4.4d line %4.4d\r",pagenum-1,line);
  380.  *         }
  381.  */
  382.           if(numbers) {
  383.               if(do_print) fprintf(lp,"%4.4d:",line_no);
  384.               col=5;
  385.           }
  386.           ++line_no;
  387.       }
  388.  
  389.       switch(c)
  390.          {
  391.          case '\n':           /* newline found */
  392.             col = 0;          /* zero column and */
  393.             line++;           /* advance line count */
  394.             if( line < MAXLINE )
  395.                if(do_print) fprintf(lp,"\n");
  396.             break;
  397.          case '\r':           /* CR found */
  398.             break;            /* discard it */
  399.          case '\t':           /* TAB found */
  400.             do
  401.                if(do_print) fputc(' ',lp);
  402.             while ( (++col % tab) != 0 );
  403.             break;
  404.          case '\f':                      /* Page break or */
  405.             if(formfeed) break;
  406.             if(line != 0)
  407.                 line = MAXLINE;      /* force termination of loop */
  408.             break;
  409.          case EOF:            /* EOF mark */
  410.          case '\377':         /* EOF mark */
  411.          case '\032':         /* EOF mark */
  412.             return(-1);
  413.          default:              /* no special case */
  414.             if(do_print) fputc(c,lp);       /* print character */
  415.             col++;
  416.             break;
  417.       }
  418.    }
  419.    return(0);
  420. }
  421.  
  422. /*************************************************************************
  423.  
  424. header
  425.    print a page header
  426.  
  427. *************************************************************************/
  428.  
  429. header( filename, pagenum )
  430. char *filename;
  431. int pagenum;
  432. {
  433.    char datestr[11], timestr[11];
  434.    if (hdrflag)  {
  435.       return;        /* skip if flag set */
  436.       }
  437.    timestamp(timestr);
  438.    datestamp(datestr);
  439.    if(do_print) fprintf(lp,"\033&d0D");
  440.    if(book && do_print)
  441.        fprintf(lp, "File: %-40s%s   %s  --  Page: %03d \n\n",
  442.           filename,datestr,timestr,pagenum);
  443.     else if(do_print)
  444.        fprintf(lp, "File: %-40s%s   %s  --  Page: %03d       \n\n",
  445.           filename,datestr,timestr,pagenum);
  446.    if(do_print) fprintf(lp,"\033&d@");
  447. }
  448.  
  449. timestamp( timestr )
  450. char   *timestr;
  451. {
  452.    struct tm *tod;
  453.    time_t tt;
  454.    tt = time(NULL);
  455.    tod = localtime(&tt);
  456.    sprintf(timestr,"%02d:%02d", tod->tm_hour, tod->tm_min);
  457.    return;
  458. }
  459.  
  460. datestamp( datestr )
  461. char  *datestr;
  462. {
  463.    struct tm *tod;
  464.    time_t tt;
  465.    tt = time(NULL);
  466.    tod = localtime(&tt);
  467.    sprintf(datestr,"%02d/%02d/%02d", tod->tm_mon + 1, tod->tm_mday,
  468.     tod->tm_year + 1900);
  469.    return;
  470. }
  471.  
  472. /*************************************************************************
  473.  
  474. dovert()
  475.    draw a vertical line down the center of the physical page
  476.  
  477. *************************************************************************/
  478.  
  479. dovert()
  480. {
  481.    int line = 1;
  482.  
  483.    if(psprint)
  484.         fprintf(lp,"\033&a0r0c123m121L\r|");
  485.    else
  486.         fprintf(lp,"\033&a0r0c90m88L\r|");
  487.  
  488.    while(line++ < MAXVERT) fprintf(lp,"\n|");
  489. }
  490.  
  491. /*************************************************************************
  492.  
  493. copyname
  494.     copy a file name converting to upper case.
  495.  
  496. *************************************************************************/
  497.  
  498. copyname(to, from)
  499. char *to, *from;
  500. {
  501.     while (*from)
  502.         *to++ = toupper(*from++);
  503.     *to = 0;
  504. }
  505.  
  506. /************************************************************************/
  507.  
  508. usage()
  509. {
  510.     printf("\nUSAGE:\n\n");
  511.     printf("C>LJ2 [flags] filename1 [filename2 ..........]\n");
  512.     printf("\tItems shown in brackets are optional.");
  513.     printf("\n\n\tFilename(s) may include wildcards");
  514.     printf("\n\n\tFlags are:\n");
  515.     printf("\t\t-e (or /e) select Helv proportional 6 PT font\n");
  516.     printf("\t\t-h (or /h) suppress page headers\n");
  517.     printf("\t\t-tx (or /tx) set tab stop value (where x is 1 to 8)\n");
  518.     printf("\t\t-p (or /p) do not leave blank half pages between files\n");
  519.     printf("\t\t-s (or /s) shade every other line\n");
  520.     printf("\t\t-n (or /n) print line numbers\n");
  521.     printf("\t\t-b (or /b) indent for punching\n");
  522.     printf("\t\t-d (or /d) for duplex printing\n");
  523.     printf("\t\t-lxx (or /lxx) set lines/page to x(where x is 1 to 66)\n");
  524.     printf("\t\t-i (or /l) ignore formfeed characters\n");
  525. }
  526.  
  527.  
  528. shade()
  529. {
  530.  
  531.  
  532.     int i;
  533.     fprintf (lp, "\033&f0S\033*p0x0Y\033*c3300a32b10G");
  534.     for (i=1; i <= 35; i++)
  535.         fprintf (lp, "\033*c2P\033&a+2R");
  536.     fprintf (lp, "\033&f1S");
  537.  
  538. }
  539.  
  540.  
  541.